package com.mall.shop.service.impl;

import com.mall.shop.entity.product.SkuInfo;
import com.mall.shop.service.SearchService;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.concurrent.*;

@Service("searchService")
public class SearchServiceImpl implements SearchService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    @Override
    public boolean productStatusUp(List<SkuInfo> products) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(20, 100, 10000, TimeUnit.SECONDS, new LinkedBlockingQueue<>(10000));
        //异步起线程执行业务 有返回值
        CompletableFuture<Integer> completableFuture = CompletableFuture
                .supplyAsync(() -> {
                    System.out.println("开始执行任务----");
                    return 1 + 2;
                }, executor)
                .whenComplete((response, exception) -> {
                    // 可以接收到返回值和异常类型，但是无法处理异常
                    System.out.println("上面任务执行完的响应对象:" + response);
                })
                .exceptionally((throwable) -> {
                    // 处理异常，返回一个自定义的值，和上边返回值无关。
                    System.out.println("此处专门处理异常");
                    return 10;
                })
                .handle((response, throwable) -> {
                    // 无论线程是否正确执行，都会执行这里，可以对返回值进行操作。
                    return 10;
                });


        // runAsync 方法无返回值，所以 CompletableFuture<Void> 中的泛型为 Void
        CompletableFuture<Void> runAsync = CompletableFuture.runAsync(() -> {
            // 这里执行一个异步任务，这个lambda表达式是一个Runnable的匿名实现
            System.out.println("[runAsync] 这是一个Runnable异步任务，该任务交由executor线程池执行");
        }, executor);

        // supplyAsync 方法有返回值，返回值类型将决定泛型，下例中lambda表达式返回String类型，所以 CompletableFuture<String> 中泛型为String
        CompletableFuture<String> supplyAsync = CompletableFuture.supplyAsync(() -> {
            // // 这里执行一个异步任务，这个lambda表达式有返回值，应该对应Callable的匿名实现
            System.out.println("[supplyAsync] 这是一个生产型异步任务,猜测对应Callable+FutureTask组合模式，该任务交由executor线程池执行");
            return "hello world";
        }, executor);

        return false;
    }

    private final ExecutorService executor = Executors.newFixedThreadPool(10);

    public void runAsyncTest() {
        // 当这个方法被调用时，可定就需要一个线程来执行,假如这个线程的名字叫做 runAsync
        System.out.println("[runAsync] 线程开始执行runAsyncTest方法");

        // 当 runAsync 线程执行到下面时，发现需要开启一个异步线程来处理，任务不归自己处理，自己接着往下执行
        CompletableFuture<Void> runAsync = CompletableFuture.runAsync(() -> {
            // 这里执行一个异步任务，这个lambda表达式是一个Runnable的匿名实现
            System.out.println("开启一个异步线程开始处理Runnable异步任务");
            System.out.println("这是一个Runnable异步任务，处理任务中---，该任务交由executor线程池执行");
            System.out.println("关闭一个异步线程完成处理Runnable异步任务");
        }, executor);

        System.out.println("[runAsync] 线程结束执行runAsyncTest方法");
    }


    public void supplyAsync() {

    }
}

